/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Logica.Controladoras.PersonaLegal;

import Logica.Core.PersonaLegal.Cliente;
import Logica.Core.PersonaLegal.ART;
import Logica.Core.PersonaLegal.Personal;
import Logica.Core.PersonaLegal.Proveedor;
import Persistencia.ControladoraPersistencia;
import Persistencia.JPAControllers.exceptions.NonexistentEntityException;
import Persistencia.JPAControllers.exceptions.PreexistingEntityException;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

/**
 *
 * @author Luciano
 */
public final class ControladoraLogicaPersonaLegal {

    protected ControladoraPersistencia miControladora;
    private List<Cliente> misClientes = new LinkedList<>();
    private List<Personal> miPersonal = new LinkedList<>();
    private List<ART> misART = new LinkedList<>();
    private List<Proveedor> misProveedores = new LinkedList<>();

    public ControladoraLogicaPersonaLegal(ControladoraPersistencia miControladora) {
        this.miControladora = miControladora;


        misClientes = dameMisClientes();
        miPersonal = dameMiPersonal();
    }

    // <editor-fold defaultstate="collapsed" desc="Clase Cliente">
    public void crearCliente(String dni, String apellido, Date fechaNacimiento, String nombre, String direccion, String telefono, String email) throws PreexistingEntityException, Exception {

        misClientes = dameMisClientes();
        int nroCliente = misClientes.size();
        boolean encontro = false;
        Cliente miNuevoCliente = new Cliente(nroCliente, dni, apellido, fechaNacimiento, nombre, direccion, email, telefono);


        for (int i = 0; i < misClientes.size() && !encontro; i++) {
            Cliente miCliente = misClientes.get(i);
            if (miCliente.getDni().equals(dni)) {
                encontro = true;
                throw new PreexistingEntityException("Cliente ya Existente.");
            }
        }

        misClientes.add(miNuevoCliente);
        miControladora.getMiPersistenciaCliente().crearCliente(miNuevoCliente);
    }

    public void darDeBajaCliente(String dni) throws NonexistentEntityException, Exception {
        misClientes = dameMisClientes();
        boolean encontro = false;
        Cliente miCliente = null;

        for (int i = 0; i < misClientes.size() && !encontro; i++) {
            miCliente = misClientes.get(i);
            if (miCliente.getDni().equals(dni)) {
                encontro = true;
                miCliente.setEstado(false);
                misClientes.set(i, miCliente);
            }
        }

        miControladora.getMiPersistenciaCliente().darDeBajaCliente(dni);
    }

    public void eliminarCliente(String dni) throws NonexistentEntityException, Exception {
        misClientes = dameMisClientes();
        boolean encontro = false;
        Cliente miCliente = null;

        for (int i = 0; i < misClientes.size() && !encontro; i++) {
            miCliente = misClientes.get(i);
            if (miCliente.getDni().equals(dni)) {
                encontro = true;
                misClientes.remove(i);
            }
        }

        miControladora.getMiPersistenciaCliente().eliminarCliente(miCliente);
    }

    public void modificarCliente(double nroCliente, String apellido, String dni, Date fechaNacimiento, String nombre, String direccion, String telefono, String email) throws NonexistentEntityException, Exception {
        misClientes = dameMisClientes();
        int pos = 0;
        boolean encuenetraCliente = false, encontro = false;
        Cliente miCliente = null;

        for (int i = 0; i < misClientes.size() && !encuenetraCliente; i++) {
            miCliente = misClientes.get(i);
            if (miCliente.getNroCliente() == nroCliente) {
                pos = i;
                encuenetraCliente = true;
            }
        }

        for (int i = 0; i < misClientes.size(); i++) {
            Cliente cliente = misClientes.get(i);
            if (cliente.getDni().equals(dni)) {
                encontro = true;
            }
        }

        if (encontro) {
            throw new Exception("Cliente ya Existente.");
        } else {
            miCliente.setApellido(apellido);
            miCliente.setDni(dni);
            miCliente.setFechaNacimiento(fechaNacimiento);
            miCliente.setNombre(nombre);
            miCliente.setDireccion(direccion);
            miCliente.setEmail(email);
            miCliente.setTelefono(telefono);

            misClientes.set(pos, miCliente);
            miControladora.getMiPersistenciaCliente().modificarCliente(miCliente);
        }
    }

    public Cliente dameUnCliente(String dni) {
        misClientes = dameMisClientes();
        boolean encontro = false;
        Cliente miCliente = null;

        for (int i = 0; i < misClientes.size() && !encontro; i++) {
            miCliente = misClientes.get(i);
            if (miCliente.getDni().equals(dni)) {
                encontro = true;
            }
        }

        return miCliente;
    }

    public List<Cliente> dameMisClientes() {
        misClientes = miControladora.getMiPersistenciaCliente().dameMisClientes();
        return misClientes;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase Personal">
    public void crearPersonal(String dni, String apellido, Date fechaNacimiento, String nombre, String direccion, String email, String telefono) throws PreexistingEntityException, Exception {

        miPersonal = dameMiPersonal();
        boolean encontro = false;
        Personal miNuevoEmpleado = new Personal(dni, apellido, fechaNacimiento, nombre, direccion, email, telefono);


        for (int i = 0; i < miPersonal.size() && !encontro; i++) {
            Personal miEmpleado = miPersonal.get(i);
            if (miEmpleado.getDni().equals(dni)) {
                encontro = true;
                throw new PreexistingEntityException("Empleado ya Existente.");
            }
        }

        miPersonal.add(miNuevoEmpleado);
        miControladora.getMiPersistenciaPersonal().crearPersonal(miNuevoEmpleado);
    }

    public void darDeBajaPersonal(String dni) throws NonexistentEntityException, Exception {
        miPersonal = dameMiPersonal();
        boolean encontro = false;
        Personal miEmpleado = null;

        for (int i = 0; i < miPersonal.size() && !encontro; i++) {
            miEmpleado = miPersonal.get(i);
            if (miEmpleado.getDni().equals(dni)) {
                encontro = true;
                miEmpleado.setEstado(false);
                miPersonal.set(i, miEmpleado);
            }
        }

        miControladora.getMiPersistenciaPersonal().darDeBajaPersonal(miEmpleado);
    }

    public void eliminarPersonal(String dni) throws NonexistentEntityException, Exception {
        miPersonal = dameMiPersonal();
        boolean encontro = false;
        Personal miEmpleado = null;

        for (int i = 0; i < miPersonal.size() && !encontro; i++) {
            miEmpleado = miPersonal.get(i);
            if (miEmpleado.getDni().equals(dni)) {
                encontro = true;
                miPersonal.remove(i);
            }
        }

        miControladora.getMiPersistenciaPersonal().eliminarPersonal(dni);
    }

    public void modificarPersonal(String dni, String apellido, Date fechaNacimiento, String nombre, String direccion, String email, String telefono) throws NonexistentEntityException, Exception {
        miPersonal = dameMiPersonal();
        boolean encontro = false;
        int pos = 0;
        Personal miEmpleado = null;

        for (int i = 0; i < miPersonal.size() && !encontro; i++) {
            miEmpleado = miPersonal.get(i);

            if (miEmpleado.getDni().equals(dni)) {
                encontro = true;
                pos = i;
            }

        }


        miEmpleado.setApellido(apellido);
        miEmpleado.setDni(dni);
        miEmpleado.setFechaNacimiento(fechaNacimiento);
        miEmpleado.setNombre(nombre);
        miEmpleado.setDireccion(direccion);
        miEmpleado.setEmail(email);
        miEmpleado.setTelefono(telefono);

        miPersonal.set(pos, miEmpleado);
        miControladora.getMiPersistenciaPersonal().modificarPersonal(miEmpleado);

    }

    public Personal dameUnPersonal(String dni) {
        miPersonal = dameMiPersonal();
        boolean encontro = false;
        Personal miEmpleado = null;

        for (int i = 0; i < miPersonal.size() && !encontro; i++) {
            miEmpleado = miPersonal.get(i);
            if (miEmpleado.getDni().equals(dni)) {
                encontro = true;
            }
        }

        return miEmpleado;
    }

    public List<Personal> dameMiPersonal() {
        miPersonal = miControladora.getMiPersistenciaPersonal().dameMiPersonal();
        return miPersonal;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase ART">
    public void crearART(String cuil, String nombre, String direccion, String email, String telefono) throws PreexistingEntityException, Exception {

        misART = dameMisART();
        boolean encontro = false;
        ART miNuevaART = new ART(cuil, nombre, direccion, email, telefono);


        for (int i = 0; i < misART.size() && !encontro; i++) {
            ART miART = misART.get(i);
            if (miART.getCuil().equals(cuil)) {
                encontro = true;
                throw new PreexistingEntityException("ART ya Existente.");
            }
        }

        misART.add(miNuevaART);
        miControladora.getMiPersistenciaART().crearART(miNuevaART);
    }

    public void darDeBajaART(String cuil) throws NonexistentEntityException, Exception {
        misART = dameMisART();
        boolean encontro = false;
        ART miART = null;

        for (int i = 0; i < misART.size() && !encontro; i++) {
            miART = misART.get(i);
            if (miART.getCuil().equals(cuil)) {
                encontro = true;
                miART.setEstado(false);
                misART.set(i, miART);
            }
        }

        miControladora.getMiPersistenciaART().darDeBajaART(miART);
    }

    public void eliminarART(String cuil) throws NonexistentEntityException, Exception {
        misART = dameMisART();
        boolean encontro = false;
        ART miART = null;

        for (int i = 0; i < misART.size() && !encontro; i++) {
            miART = misART.get(i);
            if (miART.getCuil().equals(cuil)) {
                encontro = true;
                misART.remove(i);
            }
        }

        miControladora.getMiPersistenciaART().eliminarART(cuil);
    }

    public void modificarART(String cuil, String nombre, String direccion, String email, String telefono) throws NonexistentEntityException, Exception {
        misART = dameMisART();
        boolean encontro = false;
        ART miART = null;
        int pos = 0;

        for (int i = 0; i < misART.size() && !encontro; i++) {
            miART = misART.get(i);

            if (miART.getCuil().equals(cuil)) {
                encontro = true;
                pos = i;
            }

        }

        miART.setNombre(nombre);
        miART.setDireccion(direccion);
        miART.setEmail(email);
        miART.setTelefono(telefono);

        misART.set(pos, miART);
        miControladora.getMiPersistenciaART().modificarART(miART);

    }

    public ART dameUnART(String cuil) {
        misART = dameMisART();
        boolean encontro = false;
        ART miART = null;

        for (int i = 0; i < misART.size() && !encontro; i++) {
            miART = misART.get(i);
            if (miART.getCuil().equals(cuil)) {
                encontro = true;
            }
        }

        return miART;
    }

    public List<ART> dameMisART() {
        misART = miControladora.getMiPersistenciaART().dameMisART();
        return misART;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase Proveedor">
    public void crearProveedor(String cuil, String nombre, String direccion, String email, String telefono) throws PreexistingEntityException, Exception {

        misProveedores = dameMisProveedores();
        boolean encontro = false;
        Proveedor miNuevaProveedor = new Proveedor(cuil, nombre, direccion, email, telefono);


        for (int i = 0; i < misProveedores.size() && !encontro; i++) {
            Proveedor miProveedor = misProveedores.get(i);
            if (miProveedor.getCuil().equals(cuil)) {
                encontro = true;
                throw new PreexistingEntityException("Proveedor ya Existente.");
            }
        }

        misProveedores.add(miNuevaProveedor);
        miControladora.getMiPersistenciaProveedor().crearProveedor(miNuevaProveedor);
    }

    public void darDeBajaProveedor(String cuil) throws NonexistentEntityException, Exception {
        misProveedores = dameMisProveedores();
        boolean encontro = false;
        Proveedor miProveedor = null;

        for (int i = 0; i < misProveedores.size() && !encontro; i++) {
            miProveedor = misProveedores.get(i);
            if (miProveedor.getCuil().equals(cuil)) {
                encontro = true;
                miProveedor.setEstado(false);
                misProveedores.set(i, miProveedor);
            }
        }

        miControladora.getMiPersistenciaProveedor().darDeBajaProveedor(miProveedor);
    }

    public void eliminarProveedor(String cuil) throws NonexistentEntityException, Exception {
        misProveedores = dameMisProveedores();
        boolean encontro = false;
        Proveedor miProveedor = null;

        for (int i = 0; i < misProveedores.size() && !encontro; i++) {
            miProveedor = misProveedores.get(i);
            if (miProveedor.getCuil().equals(cuil)) {
                encontro = true;
                misProveedores.remove(i);
            }
        }

        miControladora.getMiPersistenciaProveedor().eliminarProveedor(cuil);
    }

    public void modificarProveedor(String cuil, String nombre, String direccion, String email, String telefono) throws NonexistentEntityException, Exception {
        misProveedores = dameMisProveedores();
        boolean encontro = false;
        Proveedor miProveedor = null;
        int pos = 0;

        for (int i = 0; i < misProveedores.size() && !encontro; i++) {
            miProveedor = misProveedores.get(i);

            if (miProveedor.getCuil().equals(cuil)) {
                encontro = true;
                pos = i;
            }

        }


        miProveedor.setNombre(nombre);
        miProveedor.setDireccion(direccion);
        miProveedor.setEmail(email);
        miProveedor.setTelefono(telefono);

        misProveedores.set(pos, miProveedor);
        miControladora.getMiPersistenciaProveedor().modificarProveedor(miProveedor);

    }

    public Proveedor dameUnProveedor(String cuil) {
        misProveedores = dameMisProveedores();
        boolean encontro = false;
        Proveedor miProveedor = null;

        for (int i = 0; i < misProveedores.size() && !encontro; i++) {
            miProveedor = misProveedores.get(i);
            if (miProveedor.getCuil().equals(cuil)) {
                encontro = true;
            }
        }

        return miProveedor;
    }

    public List<Proveedor> dameMisProveedores() {
        misProveedores = miControladora.getMiPersistenciaProveedor().dameMisProveedores();
        return misProveedores;
    }
    // </editor-fold>
}
